"""
Vistas utilizadas 
"""
from pyramid.response import Response
from pyramid.renderers import render
import json
import re
from pyramid.httpexceptions import HTTPFound, HTTPNotFound
from pyramid.security import authenticated_userid
from alpha.modelos import DBSession
from alpha.modelos.models import DBSession2
from alpha.modelos.models import Usuario
from alpha.modelos.models import Rol
from alpha.modelos.models import Proyecto
from alpha.modelos.models import Fase
from alpha.modelos.models import Permiso
from alpha.modelos.models import AsociacionRolPermiso
from alpha.modelos.models import AsociacionUsuarioRol
from alpha.modelos.models import AsociacionFaseTipoItem
from alpha.modelos.models import AsociacionRolProyecto
from alpha.modelos.models import AsociacionRolFase
from alpha.modelos.models import AsociacionRolTipoItem
from alpha.modelos.models import TipoItem
from alpha.modelos.models import Atributo
import transaction




def redirect(request):
	"""Redirije la raiz a la vista main"""
	return HTTPFound(location= request.route_url('main'))


def main(request):
	"""Vista main, los usuarios autenticados pueden ver el contenido
	:var logged_in: contiene el nombre del usuario loggeado actualmente
	:return: retorna un diccionario con el nombre del usuario loggeado"""	
	logged_in= authenticated_userid(request)
	return dict( logged_in = logged_in, )


def usuarios(request):
	"""Vista usuarios, seccion donde se administra las operaciones referentes a los usuarios"""	
	logged_in= authenticated_userid(request)
	return dict( logged_in = logged_in, )


def roles(request):
	"""Vista roles, seccion donde se administra las operaciones referentes a los roles"""	
	logged_in= authenticated_userid(request)
	return dict( logged_in = logged_in, )


def proyectos(request):
	"""Vista proyectos, seccion donde se administra las operaciones referentes a los proyectos"""
	logged_in= authenticated_userid(request)
	return dict( logged_in = logged_in, )


def asignarUsuarios_desdeABMRol(request):
	"""Funcion que se encarga de asignar o asociar usuarios con un rol especifico
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session = DBSession()
	id_rol= int(request.params['id_rol'])
	lista_usuarios= request.params['lista_usuarios']
	lista_usuarios= lista_usuarios[1:-1].split(',')
	rol= session.query(Rol).filter_by( id= id_rol ).first()
	listaDeRelacionados=  session.query(AsociacionUsuarioRol).filter_by(right_id= id_rol).all() 
	lista_sistema= []
	lista_vista= []
	for nombreUsuarioVista in lista_usuarios:
		usuarioAux= session.query(Usuario).filter_by(nombreUsuario= nombreUsuarioVista[1:-1]).first() 
		lista_vista.append(usuarioAux)
	for asociacion in listaDeRelacionados:
		usuario= session.query(Usuario).filter_by( id= asociacion.left_id ).first() 
		lista_sistema.append(usuario)
	for usuario in lista_vista:
		if not(usuario in lista_sistema) and usuario != None :
			aso= AsociacionUsuarioRol() 
			aso.rol= rol
			aso.left_id= usuario.id
			usuario.asociacionRol.append(aso)
			session.add(usuario)
	for usuario in lista_sistema:
		if not(usuario in lista_vista):
			for aso in usuario.asociacionRol:
				if aso.right_id == id_rol:
					session.delete(aso)
	output= json.dumps({'success': True})
	return Response(output)


def asignarLider_desdeABMProyecto(request):
	"""Funcion que se encarga de asignar el rol de lider a un proyecto
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session = DBSession()
	id_proyecto= int(request.params['id_proy'])
	lista_usuarios= request.params['lista_usuarios']
	lista_usuarios= lista_usuarios[1:-1].split(',')
	username= lista_usuarios[0]
	usuario_vista= session.query(Usuario).filter_by( nombreUsuario= username[1:-1] ).first()
	proyecto=  session.query(Proyecto).filter_by( id= id_proyecto ).first()
	usuario_sistema= session.query(Usuario).filter_by( id= proyecto.lider_id ).first()
	if usuario_vista == None and usuario_sistema == None:
		output= json.dumps({'success': False, 'mensaje': 'No existe lider asignado al proyecto'})
	elif usuario_sistema != None and usuario_vista == None:
		usuario_sistema.liderProyecto.remove(proyecto)
		proyecto.lider_id= None
		session.add(usuario_sistema)
		session.add(proyecto)
		output= json.dumps({'success': True, 'mensaje':'Lider desasignado correctamente' })
	elif usuario_sistema == None and usuario_vista != None:
		usuario_vista.liderProyecto.append(proyecto)
		session.add(usuario_vista)
		output= json.dumps({'success': True, 'mensaje':'Lider asignado correctamente'})
	else :
		if usuario_vista != usuario_sistema:
			usuario_sistema.liderProyecto.remove(proyecto)
			usuario_vista.liderProyecto.append(proyecto)
			session.add(usuario_sistema)
			session.add(usuario_vista)
			output= json.dumps({'success': True})
		else:
			output= json.dumps({'success': True})
	return Response(output)


def asignarRoles_desdeABMUsuarios(request):
	"""Funcion que se encarga de asignar el rol a un usuario
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session = DBSession()
	id_usuario= int(request.params['id_usuario'])
	lista_roles= request.params['lista_roles']
	lista_roles= lista_roles[1:-1].split(',')
	"""note: obtiene el usuario a modificar"""
	usuario= session.query(Usuario).filter_by(id= id_usuario).first()
	lista_vista= []
	lista_usuario= []
	"""note: roles de la vista que se muestra en la interfaz"""
	for nombreRolVista in lista_roles: 
		rol= session.query(Rol).filter_by(nombre= nombreRolVista[1:-1]).first()
		lista_vista.append(rol)
	"""note: roles que tiene actualmente el usuario"""
	for aux in usuario.asociacionRol:
		lista_usuario.append(aux.rol)
	"""note: si el rol de la vista no esta en los del usuarios se crea la relacion y se anhade"""
	for posible in lista_vista:
		if not (posible in lista_usuario) and posible != None:
			aso= AsociacionUsuarioRol()
			aso.rol= posible
			aso.left_id= usuario.id
			usuario.asociacionRol.append(aso)
	"""note:si el rol que esta en el usuario no esta en la vista, se elimina su relacion con el usuario"""
	for posible in lista_usuario:
		if not(posible in lista_vista):
			for aso in usuario.asociacionRol:
				if aso.rol == posible:
					session.delete(aso)
	session.add(usuario)
	output= json.dumps({'success': True})
	return Response(output)


def asignarPermisos_desdeABMRol(request):
	"""Funcion que se encarga de asignar permisos a un rol
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session = DBSession()
	id_rol= int(request.params['id_rol'])
	lista_permisos= request.params['lista_permisos']
	lista_permisos= lista_permisos[1:-1].split(',')
	"""note: obtiene el rol a modificar"""
	rol= session.query(Rol).filter_by(id= id_rol).first()
	lista_vista= []
	lista_rol= []
	"""note: roles de la vista que se muestra en la interfaz"""
	for nombrePermisoVista in lista_permisos: 
		permiso= session.query(Permiso).filter_by(nombre= nombrePermisoVista[1:-1]).first()
		lista_vista.append(permiso)
	"""note: roles que tiene actualmente el usuario"""
	for aux in rol.asociacionPermiso: 
		lista_rol.append(aux.permiso)
	"""note: si el rol de la vista no esta en los del usuarios se crea la relacion y se anhade"""
	for posible in lista_vista: 
		if not (posible in lista_rol) and posible != None:
			aso= AsociacionRolPermiso()
			aso.permiso= posible
			aso.left_id= rol.id
			rol.asociacionPermiso.append(aso)
	"""note: si el rol que esta en el usuario no esta en la vista, se elimina su relacion con el usuario"""
	for posible in lista_rol:
		if not(posible in lista_vista):
			for aso in rol.asociacionPermiso:
				if aso.permiso == posible:
					session.delete(aso)
	session.add(rol)
	output= json.dumps({'success': True})
	return Response(output)


def asignarProyectos_desdeABMRol(request):
	"""Funcion que se encarga de asignar a un rol una o varios proyectos
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session = DBSession()
	id_rol= int(request.params['id_rol'])
	lista_proyectos= request.params['lista_proyectos']
	lista_proyectos= lista_proyectos[1:-1].split(',')
	id_proyectos= []
	if lista_proyectos[0] != '':
		for numero in lista_proyectos:
			id_proyectos.append(int(numero))
	"""note: obtiene el rol a modificar"""
	rol= session.query(Rol).filter_by(id= id_rol).first()
	lista_vista= []
	lista_project= []
	"""note: proyectos que estan al lado derecho del DRAG"""
	for id_proyecto in id_proyectos: 
		proyecto= session.query(Proyecto).filter_by(id= id_proyecto).first()
		lista_vista.append(proyecto)
	"""note: proyectos que tiene actualmente el rol"""
	for aux in rol.asociacionProyecto: 
		lista_project.append(aux.proyecto)
	"""note: si el rol de la vista no esta en los del usuarios se crea la relacion y se anhade"""
	for posible in lista_vista: 
		if not (posible in lista_project) and posible != None:
			aso= AsociacionRolProyecto()
			aso.proyecto= posible
			aso.left_id= rol.id
			rol.asociacionProyecto.append(aso)
	"""note: si el rol que esta en el usuario no esta en la vista, se elimina su relacion con el usuario"""
	for posible in lista_project:
		if not(posible in lista_vista):
			for aso in rol.asociacionProyecto:
				if aso.proyecto == posible:
					session.delete(aso)
	session.add(rol)
	
	output= json.dumps({'success': True})
	return Response(output)


def asignarFases_desdeABMRol(request):
	"""Funcion que se encarga de asignar a un rol una o varias fases
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session = DBSession()
	id_rol= int(request.params['id_rol'])
	lista_fases= request.params['lista_fases']
	lista_fases= lista_fases[1:-1].split(',')
	id_fases= []
	if lista_fases[0] != '':
		for numero in lista_fases:
			id_fases.append(int(numero))
	"""note: obtiene el rol a modificar"""
	rol= session.query(Rol).filter_by(id= id_rol).first()
	lista_vista= []
	lista_actuales= []
	"""note: proyectos que estan al lado derecho del DRAG"""
	for id_fase in id_fases: 
		fase= session.query(Fase).filter_by(id= id_fase).first()
		lista_vista.append(fase)
	"""note: proyectos que tiene actualmente el rol"""
	for aux in rol.asociacionFase: 
		lista_actuales.append(aux.fase)
	"""note: si el rol de la vista no esta en los del usuarios se crea la relacion y se anhade"""
	for posible in lista_vista: 
		if not (posible in lista_actuales) and posible != None:
			aso= AsociacionRolFase()
			aso.fase= posible
			aso.left_id= rol.id
			rol.asociacionFase.append(aso)
	"""note: si el rol que esta en el usuario no esta en la vista, se elimina su relacion con el usuario"""
	for posible in lista_actuales:
		if not(posible in lista_vista):
			for aso in rol.asociacionFase:
				if aso.fase == posible:
					session.delete(aso)
	session.add(rol)
	output= json.dumps({'success': True})
	return Response(output)


def asignarTiposItem_desdeABMRol(request):
	"""Funcion que se encarga de asignar tipo de item a un rol
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session = DBSession()
	id_rol= int(request.params['id_rol'])
	lista_tiposItem= request.params['lista_tiposItem']
	lista_tiposItem= lista_tiposItem[1:-1].split(',')
	id_tiposItem= []
	if lista_tiposItem[0] != '':
		for numero in lista_tiposItem:
			id_tiposItem.append(int(numero))
	"""note: obtiene el rol a modificar"""
	rol= session.query(Rol).filter_by(id= id_rol).first()
	lista_vista= []
	lista_actuales= []
	"""note: proyectos que estan al lado derecho del DRAG"""
	for id_tipo in id_tiposItem: 
		tipo= session.query(TipoItem).filter_by(id= id_tipo).first()
		lista_vista.append(tipo)
	"""note: proyectos que tiene actualmente el rol"""
	for aux in rol.asociacionTipoItem: 
		lista_actuales.append(aux.tipoItem)
	"""note: si el rol de la vista no esta en los del usuarios se crea la relacion y se anhade"""
	for posible in lista_vista: 
		if not (posible in lista_actuales) and posible != None:
			aso= AsociacionRolTipoItem()
			aso.tipoItem= posible
			aso.left_id= rol.id
			rol.asociacionTipoItem.append(aso)
	"""note: si el rol que esta en el usuario no esta en la vista, se elimina su relacion con el usuario"""
	for posible in lista_actuales:
		if not(posible in lista_vista):
			for aso in rol.asociacionTipoItem:
				if aso.tipoItem == posible:
					session.delete(aso)
	session.add(rol)
	output= json.dumps({'success': True})
	return Response(output)


def asignarTiposItem_desdeABMProyecto(request):
	"""Funcion que se encarga de asignar tipo de item a un Proyecto
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session = DBSession()
	id_fase= int(request.params['id_fase'])
	lista_tiposItem= request.params['lista_tiposItem']
	lista_tiposItem= lista_tiposItem[1:-1].split(',')
	id_tipos= []
	if lista_tiposItem[0] != '':
		for numero in lista_tiposItem:
			id_tipos.append(int(numero))
	fase= session.query(Fase).filter_by(id= id_fase).first()
	lista_vista= []
	lista_actual= []
	for id_tipo in id_tipos: 
		tipo= session.query(TipoItem).filter_by(id= id_tipo).first()
		lista_vista.append(tipo)
	for aux in fase.asociacionTipoItem: 
		lista_actual.append(aux.tipoItem)
	for posible in lista_vista: 
		if not (posible in lista_actual) and posible != None:
			aso= AsociacionFaseTipoItem()
			aso.tipoItem= posible
			aso.left_id= fase.id
			fase.asociacionTipoItem.append(aso)
	for posible in lista_actual:
		if not(posible in lista_vista):
			for aso in fase.asociacionTipoItem:
				if aso.tipoItem == posible:
					session.delete(aso)
	session.add(fase)
	output= json.dumps({'success': True})
	return Response(output)


def crearUsuarios(request):
	"""Funcion que se encarga de crear un usuario
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data= request.POST
	output= json.dumps({'success': False})
	if 'submit' in post_data:
		nombreUsuario= post_data['nombreUsuario']
		password1= post_data['password1']
		nombre= post_data['nombre']
		apellido= post_data['apellido']
		telefono= post_data['telefono']
		if telefono == "":
			telefono= 0
		nroDocumento= post_data['nroDocumento']
		if nroDocumento == "":
			nroDocumento= 0
		mail= post_data['email']
		transaction.begin()
		session= DBSession()
		usuario= Usuario(nombreUsuario, password1, nombre, apellido, telefono, nroDocumento, mail)
		session.add(usuario)
		transaction.commit()
		output= json.dumps({'success': True})
	return Response(output) 


def eliminarUsuarios(request):
	"""Funcion que se encarga de eliminar un usuario
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data= request.POST
	if 'submit' in post_data:
		session= DBSession()
		idUsuario= int(request.params['id'])
		usuario= session.query(Usuario).filter_by( id= idUsuario).first() 
		output= json.dumps({'success': False})
		en_linea = authenticated_userid(request)
		"""note: comprueba si el usuario existe en el sistema y si no esta loggeado"""
		if usuario.nombreUsuario != en_linea:
			"""note: esta condicion comprueba si el usuario tiene roles
			asociados al mismo y los elimina uno a uno mediante el for """
			for rol in usuario.asociacionRol:
				session.delete(rol)
			session.delete(usuario)
			output= json.dumps({'success': True})
	return Response(output) 


def modificarUsuarios(request):
	"""Funcion que se encarga de modificar un usuario
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data= request.POST
	if 'submit' in post_data:
		session= DBSession()
		idUsuario= int(request.params['id'])         
		usuario= session.query(Usuario).filter_by( id= idUsuario).first()
		output= json.dumps({'success': False})
		if usuario != None:
			usuario.setNombreUsuario(request.params['nombreUsuario'])
			usuario.setNombre(request.params['nombre'])
			usuario.setApellido( request.params['apellido'])
			usuario.setTelefono(request.params['telefono'])
			usuario.setNroDocumento(request.params['nroDocumento'])
			usuario.setMail( request.params['email'])
			session.add(usuario)
			output= json.dumps({'success': True})
	return Response(output)


def crearRol(request):
	"""Funcion que se encarga de crear un rol
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data= request.POST
	if 'submit' in post_data:
		nombreRol= post_data['nombreRol']
		descripcion= post_data['descripcion']
		tipo=  post_data['tipoRol']
		transaction.begin()
		session= DBSession()
		rol= Rol(nombreRol, descripcion)
		rol.setTipo(tipo)
		rol.inicializarPermisos(session)
		session.add(rol)
		transaction.commit()
		output= json.dumps({'success': True})
	return Response(output) 


def eliminarRol(request):
	"""Funcion que se encarga de eliminar un rol
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data= request.POST
	if 'submit' in post_data:
		session= DBSession()
		idRol= int(request.params['id'])
		rol= session.query(Rol).filter_by(id= idRol).first()
		output= json.dumps({'success': False})
		if rol != None:
			if rol.getNombre() == 'Administrador' :
				"""note: retorna False porque no pueden eliminarse estos dos roles"""
				return Response(output)
			"""note: all() retorna una lista, si no hay usuario asociado al rol se continua"""
			listaDeRelacionados=  session.query(AsociacionUsuarioRol).filter_by(right_id= idRol).all()
			if len(listaDeRelacionados) > 0:
				"""note: retorna False porque existen usuarios asociados"""
				return Response(output)
			"""note: elimina las relaciones con Permisos"""
			for relaciones in session.query(AsociacionRolPermiso).filter_by(left_id= rol.id).all(): 
				session.delete(relaciones)
			"""note: elimina las relaciones con Proyectos"""
			for relaciones in session.query(AsociacionRolProyecto).filter_by(left_id= rol.id).all(): 
				session.delete(relaciones)
			"""note: elimina las relaciones con Fases"""
			for relaciones in session.query(AsociacionRolFase).filter_by(left_id= rol.id).all(): 
				session.delete(relaciones)
			"""note: elimina las relaciones con Tipos Items"""
			for relaciones in session.query(AsociacionRolTipoItem).filter_by(left_id= rol.id).all(): 
				session.delete(relaciones)
			"""note: se elimina el rol"""
			session.delete(rol)
			output= json.dumps({'success': True})
	return Response(output)


def modificarRol(request):
	"""Funcion que se encarga de modificar un rol
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data = request.POST
	output = json.dumps({'success': False})
	if 'submit' in post_data:
		session= DBSession()
		idRol= int(request.params['id'])
		rol= session.query(Rol).filter_by(id= idRol).first()
		nombreModificado= False
		descripcionModificado= False
		tipoModificado= False
		if rol != None:
			if rol.getNombre() != request.params['nombreRol']:
				rol.setNombre(request.params['nombreRol'])
				nombreModificado= True
			if rol.getDescripcion() != request.params['descripcion']:
				rol.setDescripcion(request.params['descripcion'])
				descripcionModificado= True
			if request.params['tipoRol'] != rol.getTipo():
				rol.setTipo(request.params['tipoRol'])
				tipoModificado= True
				rol.inicializarPermisos(session)
				session.add(rol)
			if nombreModificado or descripcionModificado or tipoModificado:
				session.add(rol)
			output= json.dumps({'success': True})
	return Response(output)


def crearProyecto(request):
	"""Funcion que se encarga de crear un proyecto
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data= request.POST
	output= json.dumps({'success': False})
	if 'submit' in post_data:
		nombre= post_data['nombre']
		descripcion= post_data['descripcion']
		transaction.begin()
		session= DBSession()
		proyecto= Proyecto(nombre, descripcion)
		session.add(proyecto)
		proyecto= session.query(Proyecto).filter_by(nombre= nombre).first()
		rolesDeTipoAdministrador= session.query(Rol).filter_by(tipo= 'Administrador').all()
		"""note: asigna el proyecto a todos los roles de tipo Administrador"""
		for rol in rolesDeTipoAdministrador: 
			asociacion= AsociacionRolProyecto()
			asociacion.proyecto= proyecto
			asociacion.left_id= rol.id
			rol.asociacionProyecto.append(asociacion)
			session.add(rol)
		output= json.dumps({'success': True})
		transaction.commit()
	return Response(output) 


def eliminarProyecto(request):
	"""Funcion que se encarga de eliminar un proyecto
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data= request.POST
	if 'submit' in post_data:
		session= DBSession()
		idProyecto= int(request.params['id'])
		proyecto= session.query(Proyecto).filter_by(id= idProyecto).first()
		output= json.dumps({'success': False})
		if proyecto != None:
			for relacion in session.query(AsociacionRolProyecto).filter_by(right_id= proyecto.id).all():
				session.delete(relacion)
			for fase in proyecto.fases:
				for relacion in session.query(AsociacionRolFase).filter_by(right_id= fase.id).all():
					session.delete(relacion)
				"""note: se puede hacer de otra manera, pero funciona asi"""
				for relacion in session.query(AsociacionFaseTipoItem).filter_by(left_id= fase.id).all(): 
					session.delete(relacion)
				session.delete(fase)
			for tipoItem in proyecto.tipoItems:
				for relacion in session.query(AsociacionRolTipoItem).filter_by(right_id= tipoItem.id).all():
					session.delete(relacion)
				session.delete(tipoItem)
			session.delete(proyecto)
			output= json.dumps({'success': True})
	return Response(output) 


def modificarProyecto(request):
	"""Funcion que se encarga de modificar un proyecto
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	post_data= request.POST
	if 'submit' in post_data:
		session= DBSession()
		idProyecto= int(request.params['id'])
		proyecto= session.query(Proyecto).filter_by(id= idProyecto).first()
		output= json.dumps({'success': False})
		if proyecto != None:
			nombreModificado= False
			descripcionModificado= False
			nroFasesModificado= False
			if proyecto.getNombre() != request.params['nombre']:
				proyecto.setNombre(request.params['nombre'])
				nombreModificado= True
			if proyecto.getDescripcion() != request.params['descripcion']:
				proyecto.setDescripcion(request.params['descripcion'])
				descripcionModificado= True
		if  nombreModificado or descripcionModificado:
			session.add(proyecto)
			output= json.dumps({'success': True})
	return Response(output)


def iniciarProyecto(request):
	"""Funcion que cambia a estado iniciado a un proyecto"""
	session= DBSession()
	proyecto= session.query(Proyecto).filter_by(id= request.params['id']).first()
	output= json.dumps({'success': False})
	if proyecto != None: 
		if proyecto.getEstado() == 'No iniciado' and proyecto.getNroFases() > 0 and proyecto.lider_id != None:
			proyecto.setEstado('Iniciado')
			session.add(proyecto)
			output= json.dumps({'success': True})
	return Response(output)


def terminarProyecto(request):
	"""Funcion que cambia a estado terminado a un proyecto"""
	session= DBSession()
	proyecto= session.query(Proyecto).filter_by(id= request.params['id']).first()
	output= json.dumps({'success': False})
	if proyecto != None: 
		if proyecto.getEstado() == 'Iniciado':
			proyecto.setEstado('Terminado')
			session.add(proyecto)
			output= json.dumps({'success': True})
	return Response(output)


def crear_fase(request):
	"""Funcion que se encarga de crear una fase
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session= DBSession()
	id_proyecto= int(request.params['idProyectoFase'])
	nombre_fase= request.params['nombreFase']
	descripcion_fase= request.params['descripcion']
	proyecto= session.query(Proyecto).filter_by(id= id_proyecto).first()
	output= json.dumps({'success': False})
	if proyecto != None and proyecto.getEstado() == 'No iniciado':
		nuevaFase= Fase(nombre_fase, descripcion_fase)
		proyecto.fases.append(nuevaFase)
		"""note: reordena las fases en su numeracion"""
		proyecto.reEnumerarFases() 
		session.add(proyecto)
		proyecto= session.query(Proyecto).filter_by(id= proyecto.id).first()
		fase= proyecto.fases[-1]
		rolesDeTipoAdministrador= session.query(Rol).filter_by(tipo= 'Administrador').all()
		
		for rol in rolesDeTipoAdministrador: 
			asociacion= AsociacionRolFase()
			asociacion.fase= fase
			asociacion.left_id= rol.id
			rol.asociacionFase.append(asociacion)
			session.add(rol)
		output= json.dumps({'success': True})
	return Response(output)


def eliminar_fase(request):
	"""Funcion que se encarga de eliminar una fase
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session= DBSession()
	id_fase= request.params['id']
	output= json.dumps({'success': False})
	"""note: busca la fase en la BD"""
	fase= session.query(Fase).filter_by(id= id_fase).first() 
	if fase != None: 
		"""note: busca el proyecto que contiene la fase, en cuestion"""
		proyecto= session.query(Proyecto).filter_by(id= fase.proyecto_id).first() 
		for asociacion in fase.asociacionTipoItem:
			"""note: elimina las posibles asociaciones que pueda tener una fase con un tipo item"""
			session.delete(asociacion) 
		for asociacion in session.query(AsociacionRolFase).filter_by(right_id= fase.id).all():
			"""note: elimina las posibles asociaciones que pueda tener una fase con un rol"""
			session.delete(asociacion) 
		"""note: elimina la fase"""
		session.delete(fase) 
		"""note: reordena las fases en su numeracion"""
		proyecto.reEnumerarFases() 
		session.add(proyecto)
		output= json.dumps({'success': True})
	return Response(output)


def modificar_fase(request):
	"""Funcion que se encarga de modifica una fase
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session= DBSession()
	id_fase= request.params['id']
	nombre_fase= request.params['nombreFase']
	descripcion_fase= request.params['descripcion']
	output= json.dumps({'success': False})
	"""note: busca la fase en la BD"""
	fase= session.query(Fase).filter_by(id= id_fase).first() 
	if fase != None: 
		nombreModificado= False
		descripcionModificado= False
		if fase.getNombre() != nombre_fase:
			fase.setNombre(nombre_fase)
			nombreModificado= True
		if fase.getDescripcion() != descripcion_fase:
			fase.setDescripcion(descripcion_fase)
			descripcionModificado= True
		if nombreModificado or descripcionModificado:
			session.add(fase)
		output= json.dumps({'success': True})
	return Response(output)


def crear_tipo_item(request):
	"""Funcion que se encarga de crear un tipo de Item
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session= DBSession()
	id_proyecto= int(request.params['idProyecto'])
	nombre_tipo = request.params['nombre']
	descripcion_tipo= request.params['descripcion']
	proyecto= session.query(Proyecto).filter_by(id= id_proyecto).first()
	output= json.dumps({'success': False})
	if proyecto != None:
		nuevo_tipo= TipoItem(nombre_tipo, descripcion_tipo)
		proyecto.tipoItems.append(nuevo_tipo)
		session.add(proyecto)
		"""note: se anhade al rol"""
		proyecto= session.query(Proyecto).filter_by(id= proyecto.id).first()
		tipoItem= proyecto.tipoItems[-1]
		rolesDeTipoAdministrador= session.query(Rol).filter_by(tipo= 'Administrador').all()
		"""note: asigna el tipo item a todos los roles de tipo Administrador"""
		for rol in rolesDeTipoAdministrador: 
			asociacion= AsociacionRolTipoItem()
			asociacion.tipoItem= tipoItem
			asociacion.left_id= rol.id
			rol.asociacionTipoItem.append(asociacion)
			session.add(rol)
		output= json.dumps({'success': True})
	return Response(output) 


def eliminar_tipo_item(request):
	"""Funcion que se encarga de eliminar un tipo de Item
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session= DBSession()
	id_tipo= request.params['id']
	output= json.dumps({'success': False})
	"""note: busca el tipo item en la BD"""
	tipoItem= session.query(TipoItem).filter_by(id= id_tipo).first() 
	if tipoItem != None: 
		"""note: busca las asociaciones que contienen al tipo, en cuestion"""
		for asociacion in session.query(AsociacionFaseTipoItem).filter_by(right_id= tipoItem.id).all():
			"""note: elimina las posibles asociaciones que pueda tener una fase con un tipo item"""
			session.delete(asociacion) 
		for asociacion in session.query(AsociacionRolTipoItem).filter_by(right_id= tipoItem.id).all():
			"""note: elimina las posibles relaciones que pueda tener con un rol"""
			session.delete(asociacion) 
		"""note: elimina el tipo"""
		session.delete(tipoItem) 
		output= json.dumps({'success': True})
	return Response(output)


def modificar_tipo_item(request):
	"""Funcion que se encarga de modificar un tipo de Item
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session= DBSession()
	id_tipo= request.params['id']
	nombre_tipo = request.params['nombre']
	descripcion_tipo= request.params['descripcion']
	output= json.dumps({'success': False})
	"""note: busca la fase en la BD"""
	tipoItem= session.query(TipoItem).filter_by(id= id_tipo).first() 
	if tipoItem != None: 
		nombreModificado= False
		descripcionModificado= False
		if tipoItem.getNombre() != nombre_tipo:
			tipoItem.setNombre(nombre_tipo)
			nombreModificado= True
		if tipoItem.getDescripcion() != descripcion_tipo:
			tipoItem.setDescripcion(descripcion_tipo)
			descripcionModificado= True
		if nombreModificado or descripcionModificado:
			session.add(tipoItem)
		output= json.dumps({'success': True})
	return Response(output)


def importar_tipo_item(request):
	"""Funcion que se encarga de importar un tipo de Item de otros proyectos
	:return: retorna al extj un mensaje de si la operacion fue un exito o no"""
	session= DBSession()
	id_proyecto= request.params['id_proyecto']
	lista_tiposItem= request.params['lista_tiposItem']
	lista_tiposItem= lista_tiposItem[1:-1].split(',')
	id_tipos= []
	lista_para_anhadir= []
	if lista_tiposItem[0] != '':
		for numero in lista_tiposItem:
			id_tipos.append(int(numero))
	output= json.dumps({'success': False})
	for id_tipo in id_tipos:
		tipoItem= session.query(TipoItem).filter_by(id= id_tipo).first()
		lista_para_anhadir.append(tipoItem)
	proyecto= session.query(Proyecto).filter_by(id= id_proyecto).first()
	if proyecto != None:
		for tipoItem in lista_para_anhadir:
			nuevoTipoItem= TipoItem(tipoItem.getNombre(), tipoItem.getDescripcion())
			proyecto.tipoItems.append(nuevoTipoItem)
		session.add(proyecto)
		output= json.dumps({'success': True})
	return Response(output)
